// ==UserScript==
// @name      游戏至暗时刻翻译页面-事件触发
// @namespace  http://apz.homepage.com/
// @version    1.0.0
// @description  游戏至暗时刻翻译页面-事件触发
// @copyright  2023+, You
// @author       You
// @match      *://fanyi.baidu.com/*
// @icon         images/txt.png
// @require      /js/jquery-3.4.1.js
// @grant       GM_setValue
// @grant       GM_getValue
// @grant       GM_xmlhttpRequest
// @connect     10.254.2.61
// @grant       GM_setValueFromScript
// @grant       GM_sendMsgToScript 
// @grant       GM_registerMsgListener
// @downloadURL	http://127.0.0.1:8085/userScript/游戏至暗时刻翻译页面-事件触发.js
// ==/UserScript==
// @downloadURL:用户脚本更新地址
// @include：@include 指令用于指定匹配网址的规则。你可以使用通配符 * 匹配部分 URL，或使用正则表达式来匹配特定的页面。
// 例如，@include https://example.com/* 将匹配以 "https://example.com/" 开头的所有网址，而 @include /^https?:\/\/(www\.)?example\.com/ 
// 将匹配所有以 "https://" 或 "http://" 开头、以 "example.com" 结尾的网址。
// @match：@match 指令也用于指定匹配网址的规则，它支持更丰富的匹配模式。@match 使用通配符语法来匹配 URL，其中 * 可以匹配任意字符（除了 /），** 可以匹配任意字符（包括 /）。
//例如，@match https://example.com/* 和 @match *://example.com/* 都将匹配以 "https://example.com/" 开头的所有网址。
//@match https://**.example.com/* 将匹配以 "https://" 开头，以 ".example.com/" 结尾的所有网址。
//https://api.cponline.cnipa.gov.cn/zljffw/fycx/yjfywbl/listyjf-batchhdpage,{zhuanlisqhs: ["2017106745492"], size: 10, current: 1}
(function () {
    // 需要查询的专利列表
    let patentBuyList = [{ patentid: '2019110050048' }, { patentid: '2014107234471' }, { patentid: '2021114837007' }];
    // let patentBuyList = [];
    let page = 1;
    let limit = 10;

    const tmValue = 3000
    Date.prototype.format = function (fmt) {
        var o = {
            "M+": this.getMonth() + 1,                 //月份
            "d+": this.getDate(),                    //日
            "h+": this.getHours(),                   //小时
            "m+": this.getMinutes(),                 //分
            "s+": this.getSeconds(),                 //秒
            "q+": Math.floor((this.getMonth() + 3) / 3), //季度
            "S": this.getMilliseconds()             //毫秒
        };
        if (/(y+)/.test(fmt)) {
            fmt = fmt.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
        }
        for (var k in o) {
            if (new RegExp("(" + k + ")").test(fmt)) {
                fmt = fmt.replace(RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (("00" + o[k]).substr(("" + o[k]).length)));
            }
        }
        return fmt;
    };
    const initInputDomProto = () => {
        let input = document.querySelector('input');
        let descriper = Object.getOwnPropertyDescriptor(input.__proto__, 'value');
        //取出原先的get和set函数
        let getValue = descriper.get;
        let setValue = descriper.set;
        Object.defineProperty(
            input.__proto__,
            'value',
            {
                configurable: true,
                enumerable: true,
                get: function () {
                    return getValue.call(this);
                },
                // 重写set方法
                set: function () {
                    //console.log('value发生变化',arguments);
                    // 加入通知代码
                    setValue.call(this, ...arguments);
                    //this.focus()
                    this.dispatchEvent(new InputEvent("input"))
                    // this.dispatchEvent(new InputEvent("change"))
                    //this.blur()
                }
            })
    }

    // initInputDomProto()

    const listenerPElementEvent = () => {
        // 监听P元素改变内容事件
        // 选择要观察的 <p> 元素
        const targetElement = document.querySelector('p');

        // 创建 MutationObserver 对象
        const observer = new MutationObserver((mutationsList, observer) => {
            for (let mutation of mutationsList) {
                if (mutation.type === "childList") { // 如果是子节点变化
                    for (let node of mutation.addedNodes) { // 遍历添加的节点
                        console.log("文本内容发生了变化：", node.innerText);
                        if (node.nodeType === Node.TEXT_NODE) { // 只处理文本节点
                            // 处理文本节点的逻辑
                            console.log("变化内容：", node.textContent);
                        }
                    }
                } else if (mutation.type === "characterData") { // 如果是文本内容变化
                    console.log("节点发生了变化：", mutation.target.textContent);
                }
            }
        });

        // 配置观察选项
        const config = { characterData: true, subtree: true };

        // 开始观察目标元素
        observer.observe(targetElement, config);
    }
    let msgInput = {};
    let sendResponseG = null;
    let state = 0;
    const listenerAllElementEvent = (ementVlue) => {
        const callback = function (mutationsList, observer) {
            for (let mutation of mutationsList) {
                if (mutation.type === "childList") { // 如果是子节点变化
                    for (let node of mutation.addedNodes) { // 遍历添加的节点
                        if ($('.ordinary-output.target-output.clearfix')[0] && $('.ordinary-output.target-output.clearfix')[0].innerText !== '') {
                            let transRet = $('.ordinary-output.target-output.clearfix')[0].innerText;
                            console.log("翻译结果：", transRet);
                            state++;
                            // let transRet = $('.output-bd p.ordinary-output.target-output.clearfix')[0].innerText;
                            if (sendResponseG) {
                                sendResponseG({
                                    ret: 0, msg: {
                                        strInput: msgInput,
                                        result: transRet
                                    }
                                });
                            }
                        }
                    }
                } else if (mutation.type === "characterData") { // 如果是文本内容变化
                    console.log("节点发生了变化：", mutation.target.textContent);
                }
            }
        }
        //监听所有元素改变事件
        const observer = new MutationObserver(callback); // 创建 MutationObserver，指定回调函数
        // // 配置观察器选项
        // childList - 当目标节点的子节点列表发生变化时触发回调函数。如果这个属性设置为 true，则表示观察目标节点的直接子节点列表，否则表示观察整个子树中的所有节点变化。
        // attributes - 当目标节点的属性列表发生变化时触发回调函数。如果这个属性设置为 true，则表示观察目标节点的属性变化，否则表示不观察属性变化。
        // characterData - 当目标节点或其直接子节点的文本内容发生变化时触发回调函数。如果这个属性设置为 true，则表示观察目标节点以及它的直接子节点的文本内容变化，否则表示不观察文本内容变化。
        // subtree - 当目标节点的子树中任何节点发生变化时触发回调函数。如果这个属性设置为 true，则表示观察目标节点的整个子树，否则表示只观察目标节点本身。
        // attributeOldValue - 在 attributes 属性值设为 true 时，当属性值发生变化时，是否记录旧值，记录旧值在 MutationRecord 对象里的属性为 oldValue。
        // characterDataOldValue - 在 characterData 属性值设为 true 时，当文本内容发生变化时，是否记录旧值，记录旧值在 MutationRecord 对象里的属性为 oldValue。
        // attributeFilter - 一个数组，包含要观察的特定属性名称，只有这些属性发生变化才会触发回调函数。如果这个属性值为 null，则表示观察目标节点的所有属性变化。

        const observerConfig = {
            childList: true, // 观察子节点的变化
            subtree: true, // 观察目标元素的所有子孙节点
            atteibutes: false,
            // attributeFilter:['class'],
            characterData: false // 观察文本内容的变化
        };
        // 启动观察
        observer.observe(ementVlue, observerConfig);
    }



    let cnt = 10;
    let run = function () {
        cnt++;
        // 获取 top顶层节点 元素
        // let inputElement = $('#app');
        let inputElement = $('.trans-right');

        if (inputElement.length > 0) {
            console.log('事件触发接收翻译内容已启动!!!!');
            // 启动事件触发
            listenerAllElementEvent(inputElement[0]);

            GM_registerMsgListener((message, sender, sendResponse) => {
                $('#baidu_translate_input')[0].value = message.msg.value;
                $('#baidu_translate_input')[0].dispatchEvent(new Event('input', {
                    bubbles: false
                }));
                console.log("收到翻译消息:", message);
                msgInput = message;
                sendResponseG = sendResponse;
                // 超时判断
                state = 0;
                const inp = message.msg.value;
                setTimeout(function () {
                    if(!state){
                        console.log("超时消息处理:", message);
                        sendResponse({
                            ret: 0, msg: {
                                strInput: inp,
                                result: '未知'
                            }
                        });
                    }
                }, 2000)

                // const inp = message.msg.value;
                // setTimeout(function(){
                //     let transRet = $('.output-bd p.ordinary-output.target-output.clearfix')[0].innerText;
                //     console.log("收到翻译消息:", message);
                //     sendResponse({ ret: 0, msg: {
                //         strInput:inp,
                //         result:transRet}});
                // },1000)    
            });

            return true;
        } else {
            console.log('游戏至暗时刻获取APP失败!!!!');
            return false;
        }

    }


    let tt = setInterval(function () {
        if (run()) {
            clearInterval(tt)
        }
    }, tmValue);
    // chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
    //     console.log("跨域User1收到消息:", message);
    //     sendResponse('跨域User1已收到回复...');
    // });
})()